/******************************************************************************
 * 
 * Announce: CSharpKit, Basic algorithms, components and definitions.
 *           Copyright (C) ShenYongchen.
 *           All rights reserved.
 *   Author: 申永辰.郑州 (shenyczz@163.com)
 *  WebSite: http://github.com/shenyczz/CSharpKit
 *
 * THIS CODE IS LICENSED UNDER THE MIT LICENSE (MIT).
 * THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF 
 * ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
 * IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
 * PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
 * 
******************************************************************************/
using System;
using System.Runtime.InteropServices;

namespace CSharpKit.Native.BLAS
{
    partial class cblas
    {
        //{{@@@

        #region DBLAS1 -- Double precision real BLAS routines

        /// <summary>
        /// 功能：最大值出现的位置 (base_1) <br/>
        /// 状态：pass <br/>
        /// </summary>
        /// <param name="n">数组长度</param>
        /// <param name="dx">数组</param>
        /// <param name="incx">步长</param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：integer idamax_(integer* n, doublereal* dx, integer* incx) <br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "idamax_")]
        public extern static long idamax_(ref int n, double[] dx, ref int incx);

        /// <summary>
        /// 功能：求数组的累加和
        /// 原型：doublereal dasum_(integer* n, doublereal* dx, integer* incx) <br/>
        /// 状态：pass
        /// </summary>
        /// <param name="n">数组大小</param>
        /// <param name="dx">数组</param>
        /// <param name="incx">增量</param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：doublereal dasum_(integer* n, doublereal* dx, integer* incx) <br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dasum_")]
        public extern static double dasum_(ref int n, double[] dx, ref int incx);

        /// <summary>
        /// 功能：常数乘以向量加上向量: DY(I) = DY(I) + DA*DX(I) <br/>
        /// 状态：pass<br/>
        /// </summary>
        /// <param name="n">number of elements in input vector(s)</param>
        /// <param name="da">specifies the scalar alpha</param>
        /// <param name="dx">is double Precision array, dimension ( 1 + (N-1)*abs(INCX))</param>
        /// <param name="incx">storage spacing between elements of DX (DX元素之间的存储间隔)</param>
        /// <param name="dy">is double Precision array, dimension ( 1 + (N-1)*abs(INCY))</param>
        /// <param name="incy">storage spacing between elements of DY (DY元素之间的存储间隔)</param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：int daxpy_(integer* n, doublereal* da, doublereal* dx, integer* incx, doublereal* dy, integer* incy) <br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "daxpy_")]
        public extern static int daxpy_(ref int n, ref double da, double[] dx, ref int incx, double[] dy, ref int incy);

        /// <summary>
        /// 功能：copies a vector x, to a vector y<br/>
        /// 状态：pass<br/>
        /// </summary>
        /// <param name="n">number of elements in input vector(s)</param>
        /// <param name="dx"></param>
        /// <param name="incx"></param>
        /// <param name="dy"></param>
        /// <param name="incy"></param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：int dcopy_(integer* n, doublereal* dx, integer* incx, doublereal* dy, integer* incy) <br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dcopy_")]
        public extern static int dcopy_(ref int n, double[] dx, ref int incx, double[] dy, ref int incy);

        /// <summary>
        /// 功能：向量点积<br/>
        /// 状态：pass<br/>
        /// </summary>
        /// <param name="n"></param>
        /// <param name="dx"></param>
        /// <param name="incx"></param>
        /// <param name="dy"></param>
        /// <param name="incy"></param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：doublereal ddot_(integer* n, doublereal* dx, integer* incx, doublereal* dy, integer* incy)<br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "ddot_")]
        public extern static double ddot_(ref int n, double[] dx, ref int incx, double[] dy, ref int incy);

        /// <summary>
        /// 功能：计算向量的欧几里德范数，DNRM2 = sqrt( x'*x )<br/>
        /// 状态：pass<br/>
        /// </summary>
        /// <param name="n"></param>
        /// <param name="dx"></param>
        /// <param name="incx"></param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：doublereal dnrm2_(integer* n, doublereal* dx, integer* incx)<br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dnrm2_")]
        public extern static double dnrm2_(ref int n, double[] dx, ref int incx);

        /// <summary>
        /// 功能：应用平面旋转<br/>
        ///       DTEMP = C*DX(I) + S*DY(I);
        ///       DY(I) = C*DY(I) - S*DX(I);
        ///       DX(I) = DTEMP<br/>
        /// 状态：pass <br/>
        /// </summary>
        /// <param name="n">number of elements in input vector(s)</param>
        /// <param name="dx"> DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )</param>
        /// <param name="incx">storage spacing between elements of DX</param>
        /// <param name="dy">DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )</param>
        /// <param name="incy">storage spacing between elements of DY</param>
        /// <param name="c">C is DOUBLE PRECISION</param>
        /// <param name="s">S is DOUBLE PRECISION</param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：int drot_(integer* n, doublereal* dx, integer* incx, doublereal* dy, integer* incy, doublereal* c, doublereal* s)<br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "drot_")]
        public extern static int drot_(ref int n, double[] dx, ref int incx, double[] dy, ref int incy, ref double c, ref double s);

        /// <summary>
        /// 功能：构造给定的平面旋转 - waiting ??<br/>
        /// 状态：<br/>
        /// </summary>
        /// <param name="da"></param>
        /// <param name="db"></param>
        /// <param name="c"></param>
        /// <param name="s"></param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：int drotg_(doublereal* da, doublereal* db, doublereal* c, doublereal* s)<br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "drotg_")]
        public extern static int drotg_(ref double da, ref double db, ref double c, ref double s);

        /// <summary>
        /// 功能：APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX <br/>
        /// 状态：<br/>
        /// </summary>
        /// <param name="n">number of elements in input vector(s)</param>
        /// <param name="dx">DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )</param>
        /// <param name="incx">storage spacing between elements of DX</param>
        /// <param name="dy">DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )</param>
        /// <param name="incy">storage spacing between elements of DY</param>
        /// <param name="dparam">DPARAM is DOUBLE PRECISION array, dimension (5)<br/>
        ///  DPARAM(1)=DFLAG : -1,0,1,-2<br/>
        ///  DPARAM(2)=DH11<br/>
        ///  DPARAM(3)=DH21<br/>
        ///  DPARAM(4)=DH12<br/>
        ///  DPARAM(5)=DH22<br/>
        /// </param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：int drotm_(integer* n, doublereal* dx, integer* incx, doublereal* dy, integer* incy, doublereal* dparam)<br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "drotm_")]
        public extern static int drotm_(ref int n, double[] dx, ref int incx, double[] dy, ref int incy, double[] dparam);

        /// <summary>
        /// 功能：?<br/>
        /// 状态：<br/>
        /// </summary>
        /// <param name="dd1"></param>
        /// <param name="dd2"></param>
        /// <param name="dx1"></param>
        /// <param name="dy1"></param>
        /// <param name="dparam">DPARAM is DOUBLE PRECISION array, dimension (5)<br/>
        ///  DPARAM(1)=DFLAG : -1,0,1,-2<br/>
        ///  DPARAM(2)=DH11<br/>
        ///  DPARAM(3)=DH21<br/>
        ///  DPARAM(4)=DH12<br/>
        ///  DPARAM(5)=DH22<br/>
        /// </param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：int drotmg_(doublereal* dd1, doublereal* dd2, doublereal* dx1, doublereal* dy1, doublereal* dparam)<br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "drotmg_")]
        public extern static int drotmg_(ref double dd1, ref double dd2, ref double dx1, ref double dy1, double[] dparam);

        /// <summary>
        /// 功能：用常数缩放向量<br/>
        /// 状态：passed<br/>
        /// </summary>
        /// <param name="n"></param>
        /// <param name="da">specifies the scalar alpha</param>
        /// <param name="dx"></param>
        /// <param name="incx"></param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：int dscal_(integer* n, doublereal* da, doublereal* dx, integer* incx)<br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dscal_")]
        public extern static int dscal_(ref int n, ref double da, double[] dx, ref int incx);

        /// <summary>
        /// 功能：Compute the inner product of two vectors with extended precision accumulation and result. 用扩展的精度积累和结果计算两个向量的内积。<br/>
        /// 状态：<br/>
        /// </summary>
        /// <param name="n"></param>
        /// <param name="sx">single precision vector with N elements</param>
        /// <param name="incx">storage spacing between elements of SX</param>
        /// <param name="sy">single precision vector with N elements</param>
        /// <param name="incy">storage spacing between elements of SX</param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：doublereal dsdot_(integer* n, real* sx, integer* incx, real* sy, integer* incy)<br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dsdot_")]
        public extern static double dsdot_(ref int n, float[] sx, ref int incx, float[] sy, ref int incy);

        /// <summary>
        /// 功能：交换两个向量<br/>
        /// 状态：passed<br/>
        /// </summary>
        /// <param name="n"></param>
        /// <param name="dx"></param>
        /// <param name="incx"></param>
        /// <param name="dy"></param>
        /// <param name="incy"></param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：int dswap_(integer* n, doublereal* dx, integer* incx, doublereal* dy, integer* incy)<br/>
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dswap_")]
        public extern static int dswap_(ref int n, double[] dx, ref int incx, double[] dy, ref int incy);

        #endregion


        #region DBLAS2 -- Double precision real BLAS2 routines

        /// <summary>
        /// 功能：performs one of the matrix-vector operations. <br/>
        /// y := alpha*A*x + beta*y,   or   y := alpha*A**T*x + beta*y <br/>
        /// 状态：<br/>
        /// </summary>
        /// <param name="trans">
        /// TRANS specifies the operation to be performed as follows:<br/>
        /// TRANS = 'N' or 'n'   y := alpha*A*x + beta*y.<br/>
        /// TRANS = 'T' or 't'   y := alpha*A**T*x + beta*y.<br/>
        /// TRANS = 'C' or 'c'   y := alpha*A**T*x + beta*y.<br/>
        /// </param>
        /// <param name="m">specifies the number of rows of the matrix A. (>=0)</param>
        /// <param name="n">specifies the number of columns of the matrix A. (>=0)</param>
        /// <param name="kl">specifies the number of sub-diagonals of the matrix A. KL must satisfy  0 .le. KL.</param>
        /// <param name="ku">specifies the number of super-diagonals of the matrix A. KU must satisfy  0 .le. KU.</param>
        /// <param name="alpha">specifies the scalar alpha</param>
        /// <param name="A">A is DOUBLE PRECISION array, dimension ( LDA, N )</param>
        /// <param name="lda">A的第一维度。specifies the first dimension of A as declared in the calling (sub) program. LDA must be at least ( kl + ku + 1 ).</param>
        /// <param name="X">X is DOUBLE PRECISION array</param>
        /// <param name="incx">NCX specifies the increment for the elements of X</param>
        /// <param name="beta">specifies the scalar beta.</param>
        /// <param name="Y">Y is DOUBLE PRECISION array</param>
        /// <param name="incy">y增量</param>Y
        /// <returns></returns>
        /// <remarks>
        /// 原型：int dgbmv_(char* trans,
        ///     integer* m, integer* n, integer* kl, integer* ku,
        ///     doublereal* alpha,
        ///     doublereal* a, integer* lda,
        ///     doublereal* x, integer* incx,
        ///     doublereal* beta,
        ///     doublereal* y, integer* incy);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dgbmv_")]
        public extern static int dgbmv_(ref char trans,
            ref int m, ref int n, ref int kl, ref int ku,
            ref double alpha,
            double[] A, ref int lda,
            double[] X, ref int incx,
            ref double beta,
            double[] Y, ref int incy);


        /// <summary>
        /// DGEMV  performs one of the matrix-vector operations
        /// </summary>
        /// <param name="trans"></param>
        /// <param name="m"></param>
        /// <param name="n"></param>
        /// <param name="alpha"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="X"></param>
        /// <param name="incx"></param>
        /// <param name="beta"></param>
        /// <param name="Y"></param>
        /// <param name="incy"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dgemv_(char* trans,
        ///     integer* m, integer* n, doublereal*	alpha,
        ///     doublereal* a, integer* lda,
        ///     doublereal* x, integer* incx,
        /// 	doublereal* beta,
        ///     doublereal* y, integer* incy);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dgemv_")]
        public extern static int dgemv_(ref char trans,
            ref int m, ref int n, ref double alpha,
            double[] A, ref int lda,
            double[] X, ref int incx,
            ref double beta,
            double[] Y, ref int incy);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="m"></param>
        /// <param name="n"></param>
        /// <param name="alpha"></param>
        /// <param name="X"></param>
        /// <param name="incx"></param>
        /// <param name="Y"></param>
        /// <param name="incy"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dger_(integer* m, integer* n, doublereal* alpha,
        /// 	doublereal* x, integer* incx,
        ///     doublereal* y, integer* incy,
        /// 	doublereal* a, integer* lda);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dger_")]
        public extern static int dger_(ref int m, ref int n, ref double alpha,
            double[] X, ref int incx,
            double[] Y, ref int incy,
            double[] A, ref int lda
            );


        /// <summary>
        /// 
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="n"></param>
        /// <param name="k"></param>
        /// <param name="alpha"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="X"></param>
        /// <param name="incx"></param>
        /// <param name="beta"></param>
        /// <param name="Y"></param>
        /// <param name="incy"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dsbmv_(char* uplo,
        ///     integer* n, integer* k, doublereal* alpha,
        ///     doublereal* a, integer* lda,
        ///     doublereal* x, integer* incx,
        /// 	doublereal* beta,
        ///     doublereal* y, integer* incy);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dsbmv_")]
        public extern static int dsbmv_(ref char uplo,
            ref int n, ref int k, ref double alpha,
            double[] A, ref int lda,
            double[] X, ref int incx,
            ref double beta,
            double[] Y, ref int incy
            );

        /// <summary>
        /// 名称：DSPMV<br/>
        /// 功能：performs the matrix-vector operation.<br/>
        ///       y := alpha*A*x + beta*y
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="n"></param>
        /// <param name="alpha"></param>
        /// <param name="ap"></param>
        /// <param name="X"></param>
        /// <param name="incx"></param>
        /// <param name="beta"></param>
        /// <param name="Y"></param>
        /// <param name="incy"></param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：int dspmv_(char* uplo, integer* n, doublereal* alpha,
        ///     doublereal* ap,
        ///     doublereal* x, integer* incx,
        ///     doublereal* beta,
        /// 	doublereal* y, integer* incy);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dspmv_")]
        public extern static int dspmv_(ref char uplo, ref int n, ref double alpha,
            double[] ap,
            double[] X, ref int incx,
            ref double beta,
            double[] Y, ref int incy
            );

        /// <summary>
        /// 名称：DSPR<br/>
        /// 功能：performs the symmetric rank 1 operation. <br/>
        ///       A := alpha*x*x**T + A,
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="n"></param>
        /// <param name="alpha"></param>
        /// <param name="X"></param>
        /// <param name="incx"></param>
        /// <param name="A"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dspr_(char* uplo, integer* n, doublereal* alpha,
        /// 	doublereal* x, integer* incx, doublereal* ap);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dspr_")]
        public extern static int dspr_(ref char uplo, ref int n, ref double alpha,
            double[] X, ref int incx,
            double[] A
            );


        /// <summary>
        /// 名称：DSPR2<br/>
        /// 功能：performs the symmetric rank 2 operation<br/>
        ///       A := alpha*x*y**T + alpha*y*x**T + A,
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="n"></param>
        /// <param name="alpha"></param>
        /// <param name="X"></param>
        /// <param name="incx"></param>
        /// <param name="Y"></param>
        /// <param name="incy"></param>
        /// <param name="A"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dspr2_(char* uplo, integer* n, doublereal* alpha,
        /// 	doublereal* x, integer* incx, doublereal* y, integer* incy,
        /// 	doublereal* ap);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dspr2_")]
        public extern static int dspr2_(ref char uplo, ref int n, ref double alpha,
            double[] X, ref int incx,
            double[] Y, ref int incy,
            double[] A
            );



        /// <summary>
        /// 名称：DSYMV<br/>
        /// 功能：performs the matrix-vector operation.  y := alpha*A*x + beta*y<br/>
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="n"></param>
        /// <param name="alpha"></param>
        /// <param name="A">A is DOUBLE PRECISION array, dimension ( LDA, N )</param>
        /// <param name="lda"></param>
        /// <param name="x">Y is DOUBLE PRECISION array. dimension ( 1 + ( n - 1 )*abs( INCY ) )</param>
        /// <param name="incx"></param>
        /// <param name="beta">specifies the scalar beta.</param>
        /// <param name="y"></param>
        /// <param name="incy"></param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：int dsymv_(char* uplo, integer* n, doublereal* alpha,
        /// 	doublereal* a, integer* lda, doublereal* x, integer* incx, doublereal
        /// 	* beta, doublereal* y, integer* incy);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dsymv_")]
        public extern static
        int dsymv_(ref char uplo, ref int n, ref double alpha,
            double[] A, ref int lda,
            double[] x, ref int incx,
            ref double beta,
            double[] y, ref int incy
            );



        /// <summary>
        /// 名称：DSYR<br/>
        /// 功能：performs the symmetric rank 1 operation.  A := alpha*x*x**T + A <br/>
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="n"></param>
        /// <param name="alpha"></param>
        /// <param name="x"></param>
        /// <param name="incx"></param>
        /// <param name="A"></param>
        /// <param name="lda">LDA specifies the first dimension of A. must be at least max( 1, n )</param>
        /// <returns></returns>
        /// <remarks>
        /// 原型：int dsyr_(char* uplo, integer* n, doublereal* alpha,
        /// 	doublereal* x, integer* incx,
        ///     doublereal* a, integer* lda);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dsyr_")]
        public extern static
        int dsyr_(ref char uplo, ref int n, ref double alpha,
            double[] x, ref int incx,
            double[] A, ref int lda
            );


        /// <summary>
        /// 
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="n"></param>
        /// <param name="alpha"></param>
        /// <param name="x"></param>
        /// <param name="incx"></param>
        /// <param name="y"></param>
        /// <param name="incy"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dsyr2_(char* uplo, integer* n, doublereal* alpha,
        /// 	doublereal* x, integer* incx,
        ///     doublereal* y, integer* incy,
        /// 	doublereal* a, integer* lda);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dsyr2_")]
        public extern static
        int dsyr2_(ref char uplo, ref int n, ref double alpha,
            double[] x, ref int incx,
            double[] y, ref int incy,
            double[] A, ref int lda
            );



        /// <summary>
        /// 
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="trans"></param>
        /// <param name="diag"></param>
        /// <param name="n"></param>
        /// <param name="k"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="x"></param>
        /// <param name="incx"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dtbmv_(char* uplo, char* trans, char* diag,
        ///     integer* n,	integer* k,
        ///     doublereal* a, integer* lda,
        ///     doublereal* x, integer* incx);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dtbmv_")]
        public extern static
        int dtbmv_(ref char uplo, ref char trans, ref char diag,
            ref int n, ref int k,
            double[] A, ref int lda,
            double[] x, ref int incx
            );



        /// <summary>
        /// 
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="trans"></param>
        /// <param name="diag"></param>
        /// <param name="n"></param>
        /// <param name="k"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="x"></param>
        /// <param name="incx"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dtbsv_(char* uplo, char* trans, char* diag,
        ///     integer* n,	integer* k,
        ///     doublereal* a, integer* lda,
        ///     doublereal* x, integer* incx);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dtbsv_")]
        public extern static
        int dtbsv_(ref char uplo, ref char trans, ref char diag,
            ref int n, ref int k,
            double[] A, ref int lda,
            double[] x, ref int incx
            );

        /// <summary>
        /// 
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="trans"></param>
        /// <param name="diag"></param>
        /// <param name="n"></param>
        /// <param name="ap"></param>
        /// <param name="x"></param>
        /// <param name="incx"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dtpmv_(char* uplo, char* trans, char* diag,
        ///     integer* n,	doublereal* ap,
        ///     doublereal* x, integer* incx);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dtpmv_")]
        public extern static
        int dtpmv_(ref char uplo, ref char trans, ref char diag,
            ref int n, double[] ap,
            double[] x, ref int incx
            );





        /// <summary>
        /// 名称：DTPSV <br/>
        /// 功能：solves one of the systems of equations. A*x = b,   or   A**T*x = b <br/>
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="trans"></param>
        /// <param name="diag"></param>
        /// <param name="n"></param>
        /// <param name="ap"></param>
        /// <param name="x"></param>
        /// <param name="incx"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dtpsv_(char* uplo, char* trans, char* diag,
        ///     integer* n,	doublereal* ap,
        ///     doublereal* x, integer* incx);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dtpsv_")]
        public extern static
        int dtpsv_(ref char uplo, ref char trans, ref char diag,
            ref int n, double[] ap,
            double[] x, ref int incx
            );


        /// <summary>
        /// 
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="trans"></param>
        /// <param name="diag"></param>
        /// <param name="n"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="x"></param>
        /// <param name="incx"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dtrmv_(char* uplo, char* trans, char* diag,
        ///     integer* n,
        /// 	doublereal* a, integer* lda,
        ///     doublereal* x, integer* incx);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dtrmv_")]
        public extern static
        int dtrmv_(ref char uplo, ref char trans, ref char diag,
            ref int n,
            double[] A, ref int lda,
            double[] x, ref int incx
            );

        /// <summary>
        /// 
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="trans"></param>
        /// <param name="diag"></param>
        /// <param name="n"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="x"></param>
        /// <param name="incx"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dtrsv_(char* uplo, char* trans, char* diag,
        ///     integer* n,
        /// 	doublereal* a, integer* lda,
        ///     doublereal* x, integer* incx);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dtrsv_")]
        public extern static
        int dtrsv_(ref char uplo, ref char trans, ref char diag,
            ref int n,
            double[] A, ref int lda,
            double[] x, ref int incx
            );

        #endregion


        #region DBLAS3 -- Double precision real BLAS3 routines

        /// <summary>
        /// 名称：DGEMM <br/>
        /// 功能：performs one of the matrix-matrix operations。<br/>
        ///       C := alpha*op( A )*op( B ) + beta*C;<br/>
        ///       where  op( X ) is one of: op( X ) = X   or   op( X ) = X**T,
        /// <br/>
        /// </summary>
        /// <param name="transa"></param>
        /// <param name="transb"></param>
        /// <param name="m"></param>
        /// <param name="n"></param>
        /// <param name="k"></param>
        /// <param name="alpha"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="B"></param>
        /// <param name="ldb"></param>
        /// <param name="beta"></param>
        /// <param name="C_"></param>
        /// <param name="ldc"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dgemm_(char* transa, char* transb,
        ///     integer* m, integer* n, integer* k,
        ///     doublereal* alpha,
        ///     doublereal* a, integer* lda, doublereal* b, integer* ldb,
        ///     doublereal* beta, doublereal* c__, integer* ldc);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dgemm_")]
        public extern static
        int dgemm_(ref char transa, ref char transb,
            ref int m, ref int n, ref int k,
            ref double alpha, double[] A, ref int lda, double[] B, ref int ldb,
            ref double beta, double[] C_, ref int ldc
            );

        /// <summary>
        /// 
        /// </summary>
        /// <param name="side"></param>
        /// <param name="uplo"></param>
        /// <param name="m"></param>
        /// <param name="n"></param>
        /// <param name="alpha"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="B"></param>
        /// <param name="ldb"></param>
        /// <param name="beta"></param>
        /// <param name="C_"></param>
        /// <param name="ldc"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dsymm_(char* side, char* uplo, integer* m, integer* n,
        /// 	doublereal* alpha, doublereal* a, integer* lda, doublereal* b, integer* ldb,
        ///     doublereal* beta, doublereal* c__, integer* ldc);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dsymm_")]
        public extern static
        int dsymm_(ref char side, ref char uplo, ref int m, ref int n,
            ref double alpha, double[] A, ref int lda, double[] B, ref int ldb,
            ref double beta, double[] C_, ref int ldc
            );



        /// <summary>
        /// 
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="trans"></param>
        /// <param name="n"></param>
        /// <param name="k"></param>
        /// <param name="alpha"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="B"></param>
        /// <param name="ldb"></param>
        /// <param name="beta"></param>
        /// <param name="C_"></param>
        /// <param name="ldc"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dsyr2k_(char* uplo, char* trans, integer* n, integer* k,
        /// 	doublereal* alpha, doublereal* a, integer* lda, doublereal* b, integer* ldb,
        ///     doublereal* beta, doublereal* c__, integer* ldc);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dsyr2k_")]
        public extern static
        int dsyr2k_(ref char uplo, ref char trans, ref int n, ref int k,
            ref double alpha, double[] A, ref int lda, double[] B, ref int ldb,
            ref double beta, double[] C_, ref int ldc
            );


        /// <summary>
        /// 
        /// </summary>
        /// <param name="uplo"></param>
        /// <param name="trans"></param>
        /// <param name="n"></param>
        /// <param name="k"></param>
        /// <param name="alpha"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="beta"></param>
        /// <param name="C_"></param>
        /// <param name="ldc"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dsyrk_(char* uplo, char* trans, integer* n, integer* k,
        /// 	doublereal* alpha, doublereal* a, integer* lda,
        ///     doublereal* beta, doublereal* c__, integer* ldc);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dsyrk_")]
        public extern static
        int dsyrk_(ref char uplo, ref char trans, ref int n, ref int k,
            ref double alpha, double[] A, ref int lda,
            ref double beta, double[] C_, ref int ldc
            );

        /// <summary>
        /// 
        /// </summary>
        /// <param name="side"></param>
        /// <param name="uplo"></param>
        /// <param name="transa"></param>
        /// <param name="diag"></param>
        /// <param name="m"></param>
        /// <param name="n"></param>
        /// <param name="alpha"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="B"></param>
        /// <param name="ldb"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dtrmm_(char* side, char* uplo, char* transa, char* diag,
        /// 	integer* m, integer* n, doublereal* alpha,
        ///     doublereal* a, integer* lda, doublereal* b, integer* ldb);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dtrmm_")]
        public extern static
        int dtrmm_(ref char side, ref char uplo, ref char transa, ref char diag,
            ref int m, ref int n, ref double alpha,
            double[] A, ref int lda, double[] B, ref int ldb
            );


        /// <summary>
        /// 
        /// </summary>
        /// <param name="side"></param>
        /// <param name="uplo"></param>
        /// <param name="transa"></param>
        /// <param name="diag"></param>
        /// <param name="m"></param>
        /// <param name="n"></param>
        /// <param name="alpha"></param>
        /// <param name="A"></param>
        /// <param name="lda"></param>
        /// <param name="B"></param>
        /// <param name="ldb"></param>
        /// <returns></returns>
        /// <remarks>
        /// int dtrsm_(char* side, char* uplo, char* transa, char* diag,
        /// 	integer* m, integer* n, doublereal* alpha,
        ///     doublereal* a, integer* lda, doublereal* b, integer* ldb);
        /// </remarks>
        [DllImport(_dllname_, CharSet = CharSet.Ansi, EntryPoint = "dtrsm_")]
        public extern static
        int dtrsm_(ref char side, ref char uplo, ref char transa, ref char diag,
            ref int m, ref int n, ref double alpha,
            double[] A, ref int lda, double[] B, ref int ldb
            );

        /// <remarks>
        /// </remarks>

        #endregion

        //}}@@@
    }

}
